const db = require("../db/mysql");
const fs = require('fs');
const path = require('path');
const { v4: uuidv4 } = require('uuid');
const { analyzeData,streamOpenAIResponse } = require('../utils/ai/streamUtils');
/**
 * 上传文件并创建临时会话
 * @param {*} ctx 
 * *使用form data上传文件
 * * files：文件列表
 * * userid：用户ID
 * @returns {sessionId: 会话ID, files: 文件列表}
 */
const uploadFile = async (ctx) => {
    try {
        // 检查是否有文件被上传
        if (!ctx.request.files || Object.keys(ctx.request.files).length === 0) {
            ctx.status = 400;
            ctx.body = { code: 400, message: '请上传文件' };
            return;
        }

        // 获取第一个文件字段（兼容不同字段名）
        const fileField = Object.keys(ctx.request.files)[0];
        let files = ctx.request.files[fileField];

        // 确保files是数组
        if (!Array.isArray(files)) {
            files = [files];
        }

        // 获取用户ID
        const userid = ctx.request.body.userid;
        if (!userid) {
            ctx.status = 400;
            ctx.body = { code: 400, message: '用户ID不能为空' };
            return;
        }

        // 生成会话ID和文件夹名称
        const sessionId = uuidv4();
        const folderName = sessionId;
        const uploadDir = path.join(__dirname, '../uploads', folderName);

        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
        }

        // 处理文件
        const fileData = [];

        for (const file of files) {
            // 兼容不同版本的koa-body文件对象结构
            const originalName = file.originalFilename || file.name || file.filename;
            const filepath = file.filepath || file.path;
            const size = file.size;
            const mimeType = file.mimetype || file.type;

            if (!originalName || !filepath) {
                console.error('无效的文件对象:', file);
                continue;
            }

            const ext = path.extname(originalName);
            const newFilePath = path.join(uploadDir, originalName);

            // 移动文件
            fs.renameSync(filepath, newFilePath);

            fileData.push({
                originalName: originalName,
                size: size,
                mimeType: mimeType,
                fileType: ext,
                path: path.join('uploads', folderName, newFilePath).replace(/\\/g, '/') // 统一使用正斜杠
            });
        }

        if (fileData.length === 0) {
            ctx.status = 400;
            ctx.body = { code: 400, message: '没有有效的文件被上传' };
            return;
        }

        // 存入数据库
        const [result] = await db.query(
            'INSERT INTO session (sessionName, userid, sessionid, filesdata, lastTime, makeTime) VALUES (?, ?, ?, ?, NOW(),  NOW())',
            [
                "新建会话",
                userid,
                sessionId,
                JSON.stringify(fileData)
            ]
        );

        ctx.body = {
            code: 200,
            message: '文件上传成功',
            data: {
                sessionId,
                files: fileData,
                insertId: result.insertId
            }
        };
    } catch (error) {
        console.error('文件上传错误:', error);
        ctx.status = 500;
        ctx.body = {
            code: 500,
            message: '文件上传失败',
            error: process.env.NODE_ENV === 'development' ? error.message : undefined
        };
    }
};
const submitQuestion = async (ctx) => {
    try {
        const { userid, sessionId, question } = ctx.request.body;
        if (!sessionId || !question || !userid) {
            ctx.status = 400;
            ctx.body = { code: 400, message: 'sessionId和question不能为空' };
            return;
        }

        // 查询数据库中是否存在该sessionId
        const [rows] = await db.query('SELECT * FROM session WHERE sessionid = ?', [sessionId]);
        if (rows.length === 0) {
            ctx.status = 404;
            ctx.body = { code: 404, message: '会话不存在' };
            return;
        }

        // 如果名称为"新建会话"则修改为question
        if (rows[0].sessionName === "新建会话") {
            await db.query('UPDATE session SET sessionName = ?, lastTime = NOW() WHERE sessionid = ?', [question, sessionId]);
        }

        // 读取文件内容
        const files = fs.readdirSync(path.join(__dirname, '../uploads', sessionId));
        if (files.length === 0) {
            ctx.status = 404;
            ctx.body = { code: 404, message: '未找到上传的文件' };
            return;
        }

        // 读取第一个文件内容（假设是CSV格式）
        const filePath = path.join(__dirname, '../uploads', sessionId, files[0]);
        const content = fs.readFileSync(filePath, 'utf-8');
        
        // 提取前10行作为示例数据
        const lines = content.split('\n').slice(0, 10).join('\n');
        const tableContent = lines;

        // 构建问题提示
        const questionPrompt = `条件：根据表格的数据和${question}生成几个相关问题，每个问题只问一个点，不要任何解释，
要求：根据表格数据和${question}生成相关问题，第一个问题必须直接回答用户输入的精确数值问题，后续问题需包计算（如总和/平均值/极值/增长率/占比等），要求指明结果以表格的形式呈现。
排序（如按销售额排序，按销售额占比排序），要求指明结果以表格的形式呈现。可视化类问题（需指定图表类型和坐标轴）和相关性分析问题（如客流量与夜间占比的相关系数），总问题不超过五个。先生成简单排序问题，再生成图表问题。
结果：以json格式输出，严格按照json格式如下 {"问题":["问题1"，"问题2"]}，多余的内容不需要。表格数据如下:<table>${tableContent}</table>`;

        // 构建消息
        const messages = [
            { role: "system", content: "你是一个数据分析助手" },
            { role: "user", content: questionPrompt }
        ];
        // 调用阿里云AI流式接口
        const stream =  analyzeData(messages);
        console.log('stream', stream);
        ctx.status = 200;
        ctx.body = { code: 200, message: '问题提交成功', data: { stream } };
        // // 设置响应头为流式传输
        // ctx.set({
        //     'Content-Type': 'text/event-stream',
        //     'Cache-Control': 'no-cache',
        //     'Connection': 'keep-alive'
        // });
        // // 流式返回结果
        // for await (const chunk of stream) {
        //     if (chunk.type === 'stream') {
        //         // 发送流式数据
        //         ctx.res.write(`data: ${JSON.stringify({ content: chunk.content })}\n\n`);
        //         fullResponse += chunk.content;
        //     } else if (chunk.type === 'final') {
        //         // 最终处理
        //         try {
        //             // 解析AI返回的问题列表
        //             const questions = JSON.parse(fullResponse).问题 || [];
        //             // 答案列表
        //             let fullResponse = [];
        //             // 循环吧问题问给AI
        //             for (const q of questions) {
        //                 const messages = [
        //                     { role: "system", content: "你是一个数据分析助手" },
        //                     { role: "user", content: q },
        //                     { role: "assistant", content: tableContent }
        //                 ];
        //                 const response = await analyzeData(messages);
        //                 fullResponse += response;
        //             }
        //             // 将问题和回答存入数据库
        //             await db.query(
        //                 'INSERT INTO questions (userid,sessionid, question, answer, createTime) VALUES (?, ?, ?, ?, NOW())',
        //                 [userid, sessionId, question, fullResponse]
        //             );
        //             // 发送最终数据
        //             ctx.res.write(`data: ${JSON.stringify({
        //                 type: 'final',
        //                 questions,
        //                 content: fullResponse
        //             })}\n\n`);
        //         } catch (e) {
        //             console.error('解析AI响应错误:', e);
        //             ctx.res.write(`data: ${JSON.stringify({
        //                 type: 'error',
        //                 message: '解析AI响应失败'
        //             })}\n\n`);
        //         }
        //         ctx.res.end();
        //         return;
        //     }
        // }
    } catch (error) {
        console.error('提交问题错误:', error);
        ctx.status = 500;
        ctx.body = { 
            code: 500,
            message: '提交问题失败', 
            error: process.env.NODE_ENV === 'development' ? error.message : undefined 
        };
    }
};
module.exports = { uploadFile, submitQuestion };